package com.bjfu.service.impl;


import com.bjfu.dto.UpdatePasswordDTO;
import com.bjfu.mapper.*;

import com.bjfu.dto.MemberRequestDTO;

import com.bjfu.model.*;
import com.bjfu.service.GeneralService;
import com.bjfu.utils.JwtUtils;
import com.bjfu.utils.Result;
import com.bjfu.utils.ResultCodeEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;


import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.List;

import java.time.LocalDateTime;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;


@Service
public class GeneralServiceImpl implements GeneralService{
    @Autowired
    private UserMapper userMapper;  // 假设你有一个UserMapper来处理数据库操作

    @Autowired
    private UserInfoMapper userInfoMapper;

    @Autowired
    private TeamMapper teamMapper;
    @Autowired
    private ArticleMapper articleMapper;
    @Autowired
    private AchievementMapper achievementMapper;
    @Autowired
    private FileMapper fileMapper;
    @Autowired
    private ErrorInfoMapper errorInfoMapper;

    @Value("${file.upload-dir}")
    private String uploadDir;  // 文件上传目录
    @Override
    public Result getAllTeammembers() {
        List<UserInfo> members = userMapper.getAllTeammembers();
        if (members != null && !members.isEmpty()) {
            return Result.ok(members);
        } else {
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND);
        }
    }

    @Override
    public Result getMemberInfo(Long userId) { // 根据团队成员id获取某个成员信息
        // 调用 userMapper 获取指定 userId 的用户信息
        UserInfo member = userMapper.getMemberById(userId);
        // 如果查询结果为空，说明没有找到该成员
        if (member != null) {
            // 返回成员信息
            return Result.ok(member);
        } else {
            // 如果没有找到成员，返回用户未找到的结果
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND);
        }
    }


    //获取科研团队信息
    @Override
    public Result getTeam() {
        List<Team> teams = teamMapper.getTeam();
        if (teams != null && !teams.isEmpty()) {
            return Result.ok(teams);
        } else {
            return Result.build(null, ResultCodeEnum.TEAM_NOT_FOUND);
        }
    }

    // 获取文章信息
    @Override
    public Result getArticles() {
        List<Article> articles = articleMapper.getArticles();
        if (articles != null && !articles.isEmpty()) {
            return Result.ok(articles);
        } else {
            return Result.build(null, ResultCodeEnum.ARTICLE_NOT_FOUND);
        }
    }
//获取公开成果
    @Override
    public Result getOpenAchievements() {
        // 获取所有开放状态的成果
        List<Achievement> achievements = achievementMapper.getOpenAchievements(); // 查询方法需支持获取开放状态的成果

        // 判断查询结果是否为空
        if (achievements != null && !achievements.isEmpty()) {
            return Result.ok(achievements);  // 如果有结果，返回成功的结果
        } else {
            return Result.build(null, ResultCodeEnum.ACHIEVEMENT_NOT_FOUND);  // 如果没有结果，返回“未找到成果”错误信息
        }
    }

    @Override
    public Result AchievementByCategory(Integer category) {
        // 使用achievementMapper查询指定类别的成果
        List<Achievement> achievements = achievementMapper.getAchievementsByCategory(category);

        // 判断是否查询到数据
        if (achievements == null || achievements.isEmpty()) {
            return Result.build(null, ResultCodeEnum.ACHIEVEMENT_NOT_FOUND);
        }

        // 返回查询结果
        return Result.ok(achievements);
    }

    @Override
    public Result ArticleByCategory(Integer category) {
        // 使用 articleMapper 查询指定类别的文章
        List<Article> articles = articleMapper.getArticlesByCategory(category);

        // 判断是否查询到数据
        if (articles == null || articles.isEmpty()) {
            // 如果没有找到文章，返回错误信息
            return Result.build(null, ResultCodeEnum.ARTICLE_NOT_FOUND);
        }

        // 返回查询结果
        return Result.ok(articles);
    }


    @Override
    public Result getAchievementInfo(Long achievement_id) {
        // 调用 achievementMapper 查询指定 ID 的成果信息
        Achievement achievement = achievementMapper.getAchievementById(achievement_id);

        // 判断查询结果是否为空
        if (achievement == null) {
            // 如果没有找到成果，返回错误信息
            return Result.build(null, ResultCodeEnum.ACHIEVEMENT_NOT_FOUND);
        }

        // 返回查询到的成果信息
        return Result.ok(achievement);
    }
    @Override
    public Result getArticleInfo(Long article_id) {
        // 调用 articleMapper 查询指定 ID 的文章信息
        Article article = articleMapper.getArticleById(article_id);

        // 判断查询结果是否为空
        if (article == null) {
            // 如果没有找到文章，返回错误信息
            return Result.build(null, ResultCodeEnum.ARTICLE_NOT_FOUND);
        }

        // 返回查询到的文章信息
        return Result.ok(article);
    }
    @Override
    public Result getMemberName(Long user_id) {
        // 调用 userMapper 查询指定 user_id 的姓名
        String username = userMapper.getUsernameById(user_id);

        // 判断查询结果是否为空
        if (username == null) {
            // 如果没有找到用户，返回错误信息
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND);
        }

        // 返回查询到的用户名
        return Result.ok(username);
    }


    @Override
    public Result login(String username, String password) {
        // 校验用户名和密码
        User user = userMapper.getUserByUsername(username);

        if (user == null) {
            // 用户不存在
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND);
        }

        if (!user.getPassword().equals(password)) {
            // 密码错误
            return Result.build(null, ResultCodeEnum.PASSWORD_ERROR);
        }

        // 生成JWT token（这里只放入 userId 和 role）
        String token = JwtUtils.genToken(user.getUserId(), user.getRole(),user.getStatus());

        // 返回成功的响应，带上token
        return Result.ok(token);
    }



    @Override
    public Result registerTeamMember(MemberRequestDTO memberRequestDTO) {
        /*// 1. 校验用户名称是否已存在
        User existingUser = userMapper.getUserByUsername(memberRequestDTO.getUsername());
        if (existingUser != null) {
            return Result.build(null, ResultCodeEnum.USER_EXISTS);
        }*///可重名
        System.out.println(memberRequestDTO);
        // 2. 创建用户管理员或者普通用户
        User user = new User();
        user.setUsername(memberRequestDTO.getUsername());
        user.setPassword(memberRequestDTO.getPassword());
        user.setRole(memberRequestDTO.getRole()); // 团队成员2,普通用户3
        user.setStatus(0); // 初始状态为待审核
        user.setRegistrationTime(LocalDateTime.now());
        System.out.println(user);
        // 插入用户
        int rowsInserted = userMapper.insertUser(user);
        if (rowsInserted <= 0) {
            return Result.build(null, ResultCodeEnum.INSERT_FAILED);
        }

        // 3. 创建用户详细信息
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(user.getUserId());
        userInfo.setName(memberRequestDTO.getName()); // 与用户名相同
        userInfo.setApplyReason(memberRequestDTO.getApply_reason());//不允许为空，否则报错
        userInfo.setEmail(memberRequestDTO.getEmail());
        userInfo.setStatus(1); // 初始状态为待审核
        userInfo.setTeamId(1L);//只有一个团队
        //当审核通过时，既要更新user状态，也要更新user_info的状态。
        userInfo.setAvatarUrl(memberRequestDTO.getAvatar_url());
        userInfo.setResearchField(memberRequestDTO.getResearch_field());

        // 插入用户详细信息
        int infoInserted = userInfoMapper.insertUserInfo(userInfo);
        if (infoInserted <= 0) {
            return Result.build(null, ResultCodeEnum.INSERT_FAILED);
        }

        // 4. 返回成功
        return Result.ok(user);
    }

    @Override
    public Result checkUserStatus(Long user_id) {
        // 查询用户的注册状态
        User user = userMapper.getUserById(user_id);
        if (user == null) {
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND);
        }
        return Result.ok(user.getStatus());
    }

    @Override
    public Result uploadFile(MultipartFile file) throws IOException {
        String projectPath = System.getProperty("user.dir");
        String fileName = file.getOriginalFilename();
        fileName=fileName.substring(fileName.lastIndexOf(".") );
        System.out.println(fileName);
        Path targetLocation = Paths.get(projectPath, uploadDir, UUID.randomUUID().toString() + "_" + fileName);
        // 确保目录存在
        Files.createDirectories(targetLocation.getParent());
        // 将文件存储到指定位置
        Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
        // 保存文件信息到数据库
        fileMapper.saveFileMetadata(file.getOriginalFilename(), targetLocation.toString());
        return Result.ok(targetLocation);
    }

   /* @Override
    public Result downloadFile(Long fileId, HttpServletRequest request) {
        // 1. 查询数据库中的文件记录
        File file = fileMapper.getFileById(fileId);
        // 如果文件记录不存在，返回 null
        if (file == null) {
            return null;  // 文件未找到
        }
        String fileName=file.getName();
        Path path=Paths.get(file.getPath());
        // 检查文件是否存在
        if (!Files.exists(path)) {
            return Result.build("File not found", ResultCodeEnum.FILE_NOT_FOUND);
        }
        System.out.println(path.toString());

        // 如果文件存在，返回文件路径或者其他下载处理逻辑
        // 可以通过文件流等方式提供文件内容
        //而且需要返回文件而不是路径
        return Result.ok(loadFileAsResource(path));
 
    }
    // 加载文件为资源
    private Resource loadFileAsResource(Path filePath) {
        try {
            Resource resource = new FileSystemResource(filePath.toFile());
            if (resource.exists()) {
                return resource;  // 文件存在，返回资源
            } else {
                return null;  // 文件不存在
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;  // 读取文件出错
        }
    }*/
   /*@Override
   public  ResponseEntity<Resource> downloadFile(Long fileId, HttpServletRequest request) {
       // 1. 查询数据库中的文件记录
       File file = fileMapper.getFileById(fileId);
       if (file == null) {
           return ResponseEntity.notFound().build(); // 文件未找到
       }

       String fileName = file.getName();
       Path path = Paths.get(file.getPath());

       // 检查路径下文件是否存在
       if (!Files.exists(path)) {
           return ResponseEntity.notFound().build(); // 文件未找到
       }
       System.out.println("path:"+path);

       // 加载文件为资源
       Resource resource = loadFileAsResource(path);
       if (resource == null) {
           return ResponseEntity.internalServerError().build(); // 文件加载失败
       }

       // 返回文件流
       return ResponseEntity.ok()
               .contentType(MediaType.APPLICATION_OCTET_STREAM)
               .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
               .body(resource); // 直接返回文件资源
   }*/

    @Override
    public ResponseEntity<Resource> downloadFile(String filePath, HttpServletRequest request) {
        Path path = Paths.get(filePath);

        // 检查路径下文件是否存在
        if (!Files.exists(path)) {
            return ResponseEntity.notFound().build(); // 文件未找到
        }
        System.out.println("path:"+path);

        File file=fileMapper.getFileByPath(filePath);
        String fileName=file.getName();
        System.out.println(file);

        // 加载文件为资源
        Resource resource = loadFileAsResource(path);
        if (resource == null) {
            return ResponseEntity.internalServerError().build(); // 文件加载失败
        }


        // 返回文件流
        return ResponseEntity.ok()
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
                .body(resource); // 直接返回文件资源
    }

    @Override
    public Result Cancel(Long userId) {
        // 检查用户是否存在且状态为1（激活状态）
        User user = userMapper.getUserById(userId);
        if (user == null) {
            return Result.build(null, ResultCodeEnum.USER_NOT_FOUND); // 用户不存在
        }
        if (user.getStatus() != 1) {
            return Result.build(null, ResultCodeEnum.USER_NOT_ACTIVE); // 用户不是激活状态，不能注销
        }

        // 执行注销操作，将状态更新为3（注销状态）
        int result = userMapper.updateUserStatus(userId, 3);
        if (result > 0) {
            return Result.ok(null); // 注销成功
        } else {
            return Result.build(null, ResultCodeEnum.UPDATE_FAILED); // 注销失败
        }
    }

    // 加载文件为资源
    private Resource loadFileAsResource(Path filePath) {
        try {
            Resource resource = new FileSystemResource(filePath.toFile());
            if (resource.exists()) {
                return resource;  // 文件存在，返回资源
            } else {
                return null;  // 文件不存在
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;  // 读取文件出错
        }
    }

    @Override
    public Result getErrorInfoByTypeIdAndType(Long typeId, Integer type) {
        List<ErrorInfo> errorInfoList=errorInfoMapper.getErrorInfoByTypeIdAndType(typeId, type);
        if(errorInfoList.isEmpty()||errorInfoList==null){
            return Result.build(null,ResultCodeEnum.ERRORINFO_NOT_FOUND);
        }
        else{
            return Result.ok(errorInfoList);
        }
    }

    @Override
    public Result updatePassword(UpdatePasswordDTO updatePasswordDTO) {
        if(userMapper.getUserById(updatePasswordDTO.getUser_id())==null){
            return Result.build(null,ResultCodeEnum.USER_NOT_FOUND);
        }
        int result= userMapper.updatePassword(updatePasswordDTO.getUser_id(), updatePasswordDTO.getPassword());
        if(result>0){
            return Result.ok(updatePasswordDTO);
        }
        else{
            return Result.build(null,ResultCodeEnum.UPDATE_FAILED);
        }
    }
}





